home *** CD-ROM | disk | FTP | other *** search
/ Cream of the Crop 22 / Cream of the Crop 22.iso / program / ctlib100.zip / INSTALL.LZH / OBJTESTS.PAS < prev    next >
Pascal/Delphi Source File  |  1996-10-12  |  54KB  |  1,519 lines
  1. {**************************************************************************}
  2. {*  BitSoft Development, L.L.C.                                           *}
  3. {*  Copyright (C) 1995, 1996 BitSoft Development, L.L.C.                  *}
  4. {*  All rights reserved.                                                  *}
  5. {**************************************************************************}
  6.  
  7. unit ObjTests;
  8.  
  9. {$X+}
  10.  
  11. interface
  12.  
  13. uses Objects,
  14.      ctCollec, ctArrays, ctBTrees, ctBpTree,
  15.      Types;
  16.  
  17. { Arrays }
  18. procedure TestTStdArray;
  19. procedure TestTResizableStdArray;
  20. procedure TestTSortedStdArray;
  21. procedure TestTStdObjectArray;
  22. procedure TestTResizableStdObjectArray;
  23. procedure TestTSortedStdObjectArray;
  24. procedure TestTHugeArray;
  25. procedure TestTResizableHugeArray;
  26. procedure TestTSortedHugeArray;
  27. procedure TestTHugeObjectArray;
  28. procedure TestTResizableHugeObjectArray;
  29. procedure TestTSortedHugeObjectArray;
  30. procedure TestTStreamStdArray;
  31. procedure TestTEmsStdArray;
  32. procedure TestTStreamStdObjectArray;
  33. procedure TestTEmsStdObjectArray;
  34. procedure TestTStreamObjectArray;
  35. procedure TestTEmsObjectArray;
  36.  
  37. { Collections }
  38. procedure TestTHugeCollection;
  39. procedure TestTHugeSortedCollection;
  40. procedure TestTHugeStringCollection;
  41. procedure TestTHugeUnSortedStrCollection;
  42.  
  43. procedure TestTStreamCollection;
  44. procedure TestTEmsCollection;
  45. procedure TestTStreamSortedCollection;
  46. procedure TestTEmsSortedCollection;
  47. procedure TestTStreamStringCollection;
  48. procedure TestTEmsStringCollection;
  49. procedure TestTStreamUnSortedStrCollection;
  50. procedure TestTEmsUnSortedStrCollection;
  51.  
  52. { Linked Lists }
  53. procedure TestTListSingle;
  54. procedure TestTListDouble;
  55. procedure TestTSortedListSingle;
  56. procedure TestTSortedListDouble;
  57.  
  58. { Tables }
  59. procedure TestTTable;
  60. procedure TestTObjectTable;
  61.  
  62. { Queues }
  63. procedure TestTQueue;
  64. procedure TestTDoubleEndedQueue;
  65.  
  66. { Stacks }
  67. procedure TestTHugeCollectionStack;
  68. procedure TestTArrayStack;
  69. procedure TestTHugeArrayStack;
  70. procedure TestTLinkedStack;
  71. procedure TestTStreamStack;
  72. procedure TestTEmsStack;
  73.  
  74. { Binary trees }
  75. procedure TestTBinaryTree;
  76. procedure TestTAVLTree;
  77.  
  78. { B Trees }
  79. procedure TestTBTree;
  80. procedure TestTObjectBTree;
  81. procedure TestTBPlusTree;
  82. procedure TestTObjectBPlusTree;
  83.  
  84. type
  85.   PTestSortedStdArray = ^TTestSortedStdArray;
  86.   TTestSortedStdArray = object(TSortedStdArray)
  87.     function KeyOf(Item : Pointer) : Pointer; virtual;
  88.   end; { TTestSortedStdArray }
  89.  
  90. type
  91.   PTestSortedHugeArray = ^TTestSortedHugeArray;
  92.   TTestSortedHugeArray = object(TSortedHugeArray)
  93.     function KeyOf(Item : Pointer) : Pointer; virtual;
  94.   end; { TTestSortedHugeArray }
  95.  
  96. type
  97.   PTestSortedStdObjectArray = ^TTestSortedStdObjectArray;
  98.   TTestSortedStdObjectArray = object(TSortedStdObjectArray)
  99.     function KeyOf(Item : Pointer) : Pointer; virtual;
  100.   end; { TTestSortedStdObjectArray }
  101.  
  102. type
  103.   PTestSortedHugeObjectArray = ^TTestSortedHugeObjectArray;
  104.   TTestSortedHugeObjectArray = object(TSortedHugeObjectArray)
  105.     function KeyOf(Item : Pointer) : Pointer; virtual;
  106.   end; { TTestSortedHugeObjectArray }
  107.  
  108. type
  109.   PTestHugeSortedCollection = ^TTestHugeSortedCollection;
  110.   TTestHugeSortedCollection = object(THugeSortedCollection)
  111.     function KeyOf(Item : Pointer) : Pointer; virtual;
  112.   end; { TTestHugeSortedCollection }
  113.  
  114. type
  115.   PTestStreamSortedCollection = ^TTestStreamSortedCollection;
  116.   TTestStreamSortedCollection = object(TStreamSortedCollection)
  117.     function KeyOf(Item : Pointer) : Pointer; virtual;
  118.   end; { TTestStreamSortedCollection }
  119.  
  120. type
  121.   PTestEmsSortedCollection = ^TTestEmsSortedCollection;
  122.   TTestEmsSortedCollection = object(TEmsSortedCollection)
  123.     function KeyOf(Item : Pointer) : Pointer; virtual;
  124.   end; { TTestEmsSortedCollection }
  125.  
  126. type
  127.   PTestObjectBTree = ^TTestObjectBTree;
  128.   TTestObjectBTree = object(TObjectBTree)
  129.     function KeyOf(Item : Pointer) : Pointer; virtual;
  130.   end; { TTestObjectBTree }
  131.  
  132. type
  133.   PTestObjectBPlusTree = ^TTestObjectBPlusTree;
  134.   TTestObjectBPlusTree = object(TObjectBPlusTree)
  135.     function KeyOf(Item : Pointer) : Pointer; virtual;
  136.   end; { TTestObjectBPlusTree }
  137.  
  138. const
  139.   RTestHugeSortedCollection : TStreamRec = (
  140.     ObjType : idTestHugeSortedCollection;
  141.     VmtLink : Ofs(TypeOf(TTestHugeSortedCollection)^);
  142.     Load    : @TTestHugeSortedCollection.Load;
  143.     Store   : @TTestHugeSortedCollection.Store);
  144.  
  145.   RTestStreamSortedCollection : TStreamRec = (
  146.     ObjType : idTestStreamSortedCollection;
  147.     VmtLink : Ofs(TypeOf(TTestStreamSortedCollection)^);
  148.     Load    : @TTestStreamSortedCollection.Load;
  149.     Store   : @TTestStreamSortedCollection.Store);
  150.  
  151.   RTestEmsSortedCollection : TStreamRec = (
  152.     ObjType : idTestEmsSortedCollection;
  153.     VmtLink : Ofs(TypeOf(TTestEmsSortedCollection)^);
  154.     Load    : @TTestEmsSortedCollection.Load;
  155.     Store   : @TTestEmsSortedCollection.Store);
  156.  
  157.  
  158. implementation
  159.  
  160. uses App, MsgBox,
  161.      BsdTypes,
  162.      ctLists, ctTables, ctFields, ctQueues, ctStacks, ctBiTree,
  163.      Data, Display, Readers, Utils, TstScrpt;
  164.  
  165. {****************************************************************************}
  166. {*                                                                          *}
  167. {*                        EXPORTED OBJECT DECLARATIONS                      *}
  168. {*                                                                          *}
  169. {****************************************************************************}
  170. {****************************************************************************}
  171. { TTestEMSSortedCollection object                                            }
  172. {****************************************************************************}
  173. {****************************************************************************}
  174. { TTestEMSSortedCollection.KeyOf                                             }
  175. {****************************************************************************}
  176. function TTestEmsSortedCollection.KeyOf(Item : Pointer) : Pointer;
  177. begin
  178.   KeyOf := PTestObject(Item)^.Text;
  179. end;
  180.  
  181. {****************************************************************************}
  182. { TTestObjectBPlusTree object                                                }
  183. {****************************************************************************}
  184. {****************************************************************************}
  185. { TTestObjectBPlusTree.KeyOf                                                 }
  186. {****************************************************************************}
  187. function TTestObjectBPlusTree.KeyOf(Item : Pointer) : Pointer;
  188. begin
  189.   KeyOf := @PTestStaticObject(Item)^.Text;
  190. end;
  191.  
  192. {****************************************************************************}
  193. { TTestObjectBTree object                                                    }
  194. {****************************************************************************}
  195. {****************************************************************************}
  196. { TTestObjectBTree.KeyOf                                                     }
  197. {****************************************************************************}
  198. function TTestObjectBTree.KeyOf(Item : Pointer) : Pointer;
  199. begin
  200.   KeyOf := @PTestStaticObject(Item)^.Text;
  201. end;
  202.  
  203. {****************************************************************************}
  204. { TTestHugeSortedCollection object                                           }
  205. {****************************************************************************}
  206. {****************************************************************************}
  207. { TTestHugeSortedCollection.KeyOf                                            }
  208. {****************************************************************************}
  209. function TTestHugeSortedCollection.KeyOf(Item : Pointer) : Pointer;
  210. begin
  211.   KeyOf := PTestObject(Item)^.Text;
  212. end;
  213.  
  214. {****************************************************************************}
  215. { TTestSortedHugeArray object                                                }
  216. {****************************************************************************}
  217. {****************************************************************************}
  218. { TTestSortedHugeArray.KeyOf                                                 }
  219. {****************************************************************************}
  220. function TTestSortedHugeArray.KeyOf(Item : Pointer) : Pointer;
  221. begin
  222.   KeyOf := @PTestRec(Item)^.Key;
  223. end;
  224.  
  225. {****************************************************************************}
  226. { TTestSortedHugeObjectArray                                                 }
  227. {****************************************************************************}
  228. function TTestSortedHugeObjectArray.KeyOf(Item : Pointer) : Pointer;
  229. begin
  230.   KeyOf := @PTestStaticObject(Item)^.Text;
  231. end;
  232.  
  233. {****************************************************************************}
  234. { TTestSortedStdArray object                                                 }
  235. {****************************************************************************}
  236. {****************************************************************************}
  237. { TTestSortedStdArray.KeyOf                                                  }
  238. {****************************************************************************}
  239. function TTestSortedStdArray.KeyOf(Item : Pointer) : Pointer;
  240. begin
  241.   KeyOf := @PTestRec(Item)^.Key;
  242. end;
  243.  
  244. {****************************************************************************}
  245. { TTestSortedStdObjectArray                                                  }
  246. {****************************************************************************}
  247. function TTestSortedStdObjectArray.KeyOf(Item : Pointer) : Pointer;
  248. begin
  249.   KeyOf := @PTestStaticObject(Item)^.Text;
  250. end;
  251.  
  252. {****************************************************************************}
  253. { TTestStreamSortedCollection object                                         }
  254. {****************************************************************************}
  255. {****************************************************************************}
  256. { TTestStreamSortedCollection.KeyOf                                          }
  257. {****************************************************************************}
  258. function TTestStreamSortedCollection.KeyOf(Item : Pointer) : Pointer;
  259. begin
  260.   KeyOf := PTestObject(Item)^.Text;
  261. end;
  262.  
  263. {****************************************************************************}
  264. {*                                                                          *}
  265. {*                      EXPORTED FUNCTIONS AND PROCEDURES                   *}
  266. {*                                                                          *}
  267. {****************************************************************************}
  268.  
  269. {****************************************************************************}
  270. { TestTArrayStack                                                            }
  271. {****************************************************************************}
  272. procedure TestTArrayStack;
  273. var
  274.   Stack : PArrayStack;
  275.   Reader : PTestRecReader;
  276.   Window : PResultsWindow;
  277. begin
  278.   Stack := New(PArrayStack, Init(30, 50, SizeOf(TTestRec)));
  279.   if Stack = nil
  280.     then Exit;
  281.   Reader := New(PTestRecReader, Init(Stack));
  282.   Window := New(PResultsWindow, Init('TArrayStack test', Reader));
  283.   InitTest(Reader, Window, nil);
  284.   TestArrayStack(Stack);
  285.   EndTest;
  286. end;
  287.  
  288. {****************************************************************************}
  289. { TestTAVLTree                                                               }
  290. {****************************************************************************}
  291. procedure TestTAVLTree;
  292. var
  293.   Tree : PAVLTree;
  294.   Reader : PTestAVLNodeReader;
  295.   Window : PResultsWindow;
  296. begin
  297.   Tree := New(PAVLTree, Init);
  298.   if Tree= nil
  299.     then Exit;
  300.   Reader := New(PTestAVLNodeReader, Init(Tree));
  301.   Window := New(PResultsWindow, Init('TAVLTree test', Reader));
  302.   InitTest(Reader, Window, CreateAVLNode);
  303.   TestBinaryTree(Tree);
  304.   EndTest;
  305. end;
  306.  
  307. {****************************************************************************}
  308. { TestTBinaryTree                                                            }
  309. {****************************************************************************}
  310. procedure TestTBinaryTree;
  311. var
  312.   Tree : PBinaryTree;
  313.   Reader : PTestBinaryNodeReader;
  314.   Window : PResultsWindow;
  315. begin
  316.   Tree := New(PBinaryTree, Init);
  317.   if Tree= nil
  318.     then Exit;
  319.   Reader := New(PTestBinaryNodeReader, Init(Tree));
  320.   Window := New(PResultsWindow, Init('TBinaryTree test', Reader));
  321.   InitTest(Reader, Window, CreateBinaryNode);
  322.   TestBinaryTree(Tree);
  323.   EndTest;
  324. end;
  325.  
  326. {****************************************************************************}
  327. { TestTBPlusTree                                                             }
  328. {****************************************************************************}
  329. procedure TestTBPlusTree;
  330. var
  331.   Stream : PStream;
  332.   Tree : PBPlusTree;
  333.   Reader : PBTreeReader;
  334.   Window : PResultsWindow;
  335.   OldTotalItems : LongInt;
  336. begin
  337.   Stream := New(PBufStream, Init(TreesTempFileName, stCreate, 2048));
  338.   if Stream = nil
  339.     then begin
  340.            Application^.OutOfMemory;
  341.            Exit;
  342.          end { if }
  343.   else if Stream^.Status <> stOk
  344.     then begin
  345.            MessageBox('Error ocurred while initializing stream.',
  346.              nil, mfError + mfOkButton);
  347.            Dispose(Stream, Done);
  348.            Exit;
  349.          end; { if }
  350.   Tree := New(PBPlusTree, Init(13, 20, SizeOf(TTestRec), SizeOf(String5),
  351.             Stream, 50, 50));
  352.   if Tree = nil
  353.     then Exit;
  354.   Reader := New(PBTreeReader, Init(Tree));
  355.   Window := New(PResultsWindow, Init('TBPlusTree test', Reader));
  356.  
  357.   OldTotalItems := TotalItems;
  358.   if TotalItems > 3000
  359.     then begin
  360.            Writeln(Window^.T, 'For speed, number of items has been reduced '+
  361.              'to 3000.');
  362.            Writeln(Window^.T);
  363.            TotalItems := 3000;
  364.          end; { if }
  365.   Writeln(Window^.T, 'The size of the buffer is 12 Kb.');
  366.   Writeln(Window^.T);
  367.  
  368.   InitTest(Reader, Window, nil);
  369.   UseNonDynamicTestRec := True;
  370.   TestGraph(Tree);
  371.   UseNonDynamicTestRec := False;
  372.   if PResultsWindow(Desktop^.Current) = Window
  373.     then begin
  374.            Dispose(Tree, Done);
  375.            Reader^.Container := nil;
  376.            NotifyDataChange;
  377.            Window^.Redraw;
  378.          end; { if }
  379.   Dispose(Stream, Done);
  380.   TotalItems := OldTotalItems;
  381.   EndTest;
  382. end;
  383.  
  384. {****************************************************************************}
  385. { TestTBTree                                                                 }
  386. {****************************************************************************}
  387. procedure TestTBTree;
  388. var
  389.   Stream : PStream;
  390.   Tree : PBTree;
  391.   Reader : PBTreeReader;
  392.   Window : PResultsWindow;
  393.   OldTotalItems : LongInt;
  394. begin
  395.   Stream := New(PBufStream, Init(TreesTempFileName, stCreate, 2048));
  396.   if Stream = nil
  397.     then begin
  398.            Application^.OutOfMemory;
  399.            Exit;
  400.          end { if }
  401.   else if Stream^.Status <> stOk
  402.     then begin
  403.            MessageBox('Error ocurred while initializing stream.',
  404.              nil, mfError + mfOkButton);
  405.            Dispose(Stream, Done);
  406.            Exit;
  407.          end; { if }
  408.   Tree := New(PBTree, Init(15, SizeOf(TTestRec), Stream, 100));
  409.   if Tree = nil
  410.     then Exit;
  411.   Reader := New(PBTreeReader, Init(Tree));
  412.   Window := New(PResultsWindow, Init('TBTree test', Reader));
  413.  
  414.   OldTotalItems := TotalItems;
  415.   if TotalItems > 3000
  416.     then begin
  417.            Writeln(Window^.T, 'For speed, number of items has been reduced '+
  418.              'to 3000.');
  419.            Writeln(Window^.T);
  420.            TotalItems := 3000;
  421.          end; { if }
  422.   Writeln(Window^.T, 'The size of the buffer is 20 Kb.');
  423.   Writeln(Window^.T);
  424.  
  425.   InitTest(Reader, Window, nil);
  426.   UseNonDynamicTestRec := True;
  427.   TestGraph(Tree);
  428.   UseNonDynamicTestRec := False;
  429.   if PResultsWindow(Desktop^.Current) = Window
  430.     then begin
  431.            Dispose(Tree, Done);
  432.            Reader^.Container := nil;
  433.            NotifyDataChange;
  434.            Window^.Redraw;
  435.          end; { if }
  436.   Dispose(Stream, Done);
  437.   TotalItems := OldTotalItems;
  438.   EndTest;
  439. end;
  440.  
  441. {****************************************************************************}
  442. { TestTDoubleEndedQueue                                                      }
  443. {****************************************************************************}
  444. procedure TestTDoubleEndedQueue;
  445. var
  446.   Queue : PDoubleEndedQueue;
  447.   Reader : PTestListNodeReader;
  448.   Window : PResultsWindow;
  449. begin
  450.   Queue := New(PDoubleEndedQueue, Init);
  451.   if Queue = nil
  452.     then Exit;
  453.   Reader := New(PTestListNodeReader, Init(Queue));
  454.   Window := New(PResultsWindow, Init('TDoubleEndedQueue test', Reader));
  455.   InitTest(Reader, Window, CreateListNode);
  456.   TestDoubleEndedQueue(Queue);
  457.   EndTest;
  458. end;
  459.  
  460. {****************************************************************************}
  461. { TestTEmsCollection                                                         }
  462. {****************************************************************************}
  463. procedure TestTEmsCollection;
  464. var
  465.   Collection : PEmsCollection;
  466.   Reader : PTestObjectReader;
  467.   Window : PResultsWindow;
  468. begin
  469.   Collection := New(PEmsCollection, Init(TotalItems, 50));
  470.   if Collection = nil
  471.     then Exit;
  472.   Reader := New(PTestObjectReader, Init(Collection));
  473.   Window := New(PResultsWindow, Init('TEmsCollection test', Reader));
  474.   InitTest(Reader, Window, CreateTestObject);
  475.   TestSequence(Collection, Dynamic, UnSorted);
  476.   EndTest;
  477. end;
  478.  
  479. {****************************************************************************}
  480. { TestTEmsObjectArray                                                        }
  481. {****************************************************************************}
  482. procedure TestTEmsObjectArray;
  483. var
  484.   DemoArray: PEmsObjectArray;
  485.   Reader : PTestStaticObjectReader;
  486.   Window : PResultsWindow;
  487. begin
  488.   DemoArray := New(PEmsObjectArray, Init(0, Pred(TotalItems),
  489.     SizeOf(TTestStaticObject)));
  490.   if DemoArray = nil
  491.     then Exit;
  492.   Reader := New(PTestStaticObjectReader, Init(DemoArray));
  493.   Window := New(PResultsWindow, Init('TEmsObjectArray test', Reader));
  494.   InitTest(Reader, Window, CreateStaticObject);
  495.   TestArray(DemoArray);
  496.   EndTest;
  497. end;
  498.  
  499. {****************************************************************************}
  500. { TestTEmsSortedCollection                                                   }
  501. {****************************************************************************}
  502. procedure TestTEmsSortedCollection;
  503. var
  504.   Collection : PEmsSortedCollection;
  505.   Reader : PTestObjectReader;
  506.   Window : PResultsWindow;
  507. begin
  508.   Collection := New(PTestEmsSortedCollection, Init(TotalItems, 50));
  509.   if Collection = nil
  510.     then Exit;
  511.   Reader := New(PTestObjectReader, Init(Collection));
  512.   Window := New(PResultsWindow, Init('TEmsSortedCollection test', Reader));
  513.   InitTest(Reader, Window, CreateTestObject);
  514.   TestSequence(Collection, Dynamic, Sorted);
  515.   EndTest;
  516. end;
  517.  
  518. {****************************************************************************}
  519. { TestTEmsStack                                                              }
  520. {****************************************************************************}
  521. procedure TestTEmsStack;
  522. var
  523.   Stack: PEmsStack;
  524.   Reader : PTestObjectReader;
  525.   Window : PResultsWindow;
  526. begin
  527.   Stack := New(PEmsStack, Init(100, 10));
  528.   if Stack = nil
  529.     then Exit;
  530.   Reader := New(PTestObjectReader, Init(Stack));
  531.   Window := New(PResultsWindow, Init('TEmsStack test', Reader));
  532.   InitTest(Reader, Window, CreateTestObject);
  533.   TestStreamStack(Stack);
  534.   EndTest;
  535. end;
  536.  
  537. {****************************************************************************}
  538. { TestTEmsStdArray                                                           }
  539. {****************************************************************************}
  540. procedure TestTEmsStdArray;
  541. var
  542.   DemoArray: PEmsStdArray;
  543.   Reader : PTestRecReader;
  544.   Window : PResultsWindow;
  545. begin
  546.   DemoArray := New(PEmsStdArray, Init(0, Pred(TotalItems),
  547.     SizeOf(TTestRec)));
  548.   if DemoArray = nil
  549.     then Exit;
  550.   Reader := New(PTestRecReader, Init(DemoArray));
  551.   Window := New(PResultsWindow, Init('TEmsStdArray test', Reader));
  552.   InitTest(Reader, Window, CreateTestRec);
  553.   TestArray(DemoArray);
  554.   EndTest;
  555. end;
  556.  
  557. {****************************************************************************}
  558. { TestTEmsStdObjectArray                                                        }
  559. {****************************************************************************}
  560. procedure TestTEmsStdObjectArray;
  561. var
  562.   DemoArray: PEmsStdObjectArray;
  563.   Reader : PTestObjectReader;
  564.   Window : PResultsWindow;
  565. begin
  566.   DemoArray := New(PEmsStdObjectArray, Init(0, Pred(TotalItems),
  567.     SizeOf(TTestObject)));
  568.   if DemoArray = nil
  569.     then Exit;
  570.   Reader := New(PTestObjectReader, Init(DemoArray));
  571.   Window := New(PResultsWindow, Init('TEmsStdObjectArray test', Reader));
  572.   InitTest(Reader, Window, CreateTestObject);
  573.   TestArray(DemoArray);
  574.   EndTest;
  575. end;
  576.  
  577. {****************************************************************************}
  578. { TestTEmsStringCollection                                                   }
  579. {****************************************************************************}
  580. procedure TestTEmsStringCollection;
  581. var
  582.   Collection : PEmsStringCollection;
  583.   Reader : PStringReader;
  584.   Window : PResultsWindow;
  585. begin
  586.   Collection := New(PEmsStringCollection, Init(TotalItems, 50));
  587.   if Collection = nil
  588.     then Exit;
  589.   Reader := New(PStringReader, Init(Collection));
  590.   Window := New(PResultsWindow, Init('TEmsStringCollection test', Reader));
  591.   InitTest(Reader, Window, CreateString);
  592.   TestSequence(Collection, Dynamic, Sorted);
  593.   EndTest;
  594. end;
  595.  
  596. {****************************************************************************}
  597. { TestTEmsUnSortedStrCollection                                              }
  598. {****************************************************************************}
  599. procedure TestTEmsUnSortedStrCollection;
  600. var
  601.   Collection : PEmsUnSortedStrCollection;
  602.   Reader : PTestObjectReader;
  603.   Window : PResultsWindow;
  604. begin
  605.   Collection := New(PEmsUnSortedStrCollection, Init(TotalItems, 50));
  606.   if Collection = nil
  607.     then Exit;
  608.   Reader := New(PTestObjectReader, Init(Collection));
  609.   Window := New(PResultsWindow, Init('TEmsUnSortedStrCollection test',
  610.     Reader));
  611.   InitTest(Reader, Window, CreateTestObject);
  612.   TestSequence(Collection, Dynamic, UnSorted);
  613.   EndTest;
  614. end;
  615.  
  616. {****************************************************************************}
  617. { TestTHugeArray                                                             }
  618. {****************************************************************************}
  619. procedure TestTHugeArray;
  620. var
  621.   DemoArray: PHugeArray;
  622.   Reader : PTestRecReader;
  623.   Window : PResultsWindow;
  624. begin
  625.   DemoArray := New(PHugeArray, Init(0, Pred(TotalItems),
  626.     SizeOf(TTestRec)));
  627.   if DemoArray = nil
  628.     then Exit;
  629.   Reader := New(PTestRecReader, Init(DemoArray));
  630.   Window := New(PResultsWindow, Init('THugeArray test', Reader));
  631.   InitTest(Reader, Window, nil);
  632.   UseNonDynamicTestRec := True;
  633.   TestingMemArray := True;
  634.   TestArray(DemoArray);
  635.   UseNonDynamicTestRec := False;
  636.   TestingMemArray := False;
  637.   EndTest;
  638. end;
  639.  
  640. {****************************************************************************}
  641. { TestTHugeArrayStack                                                        }
  642. {****************************************************************************}
  643. procedure TestTHugeArrayStack;
  644. var
  645.   Stack : PHugeArrayStack;
  646.   Reader : PTestRecReader;
  647.   Window : PResultsWindow;
  648. begin
  649.   Stack := New(PHugeArrayStack, Init(30, 50, SizeOf(TTestRec)));
  650.   if Stack = nil
  651.     then Exit;
  652.   Reader := New(PTestRecReader, Init(Stack));
  653.   Window := New(PResultsWindow, Init('THugeArrayStack test', Reader));
  654.   InitTest(Reader, Window, nil);
  655.   TestHugeArrayStack(Stack);
  656.   EndTest;
  657. end;
  658.  
  659. {****************************************************************************}
  660. { TestTHugeObjectArray                                                       }
  661. {****************************************************************************}
  662. procedure TestTHugeObjectArray;
  663. var
  664.   DemoArray: PHugeObjectArray;
  665.   Reader : PTestObjectReader;
  666.   Window : PResultsWindow;
  667. begin
  668.   DemoArray := New(PHugeObjectArray, Init(0, Pred(TotalItems),
  669.     SizeOf(TTestObject)));
  670.   if DemoArray = nil
  671.     then Exit;
  672.   Reader := New(PTestObjectReader, Init(DemoArray));
  673.   Window := New(PResultsWindow, Init('THugeObjectArray test', Reader));
  674.   InitTest(Reader, Window, nil);
  675.   UseNonDynamicTestObject := True;
  676.   TestingMemArray := True;
  677.   TestArray(DemoArray);
  678.   UseNonDynamicTestObject := False;
  679.   TestingMemArray := False;
  680.   EndTest;
  681. end;
  682.  
  683. {****************************************************************************}
  684. { TestTHugeCollection                                                        }
  685. {****************************************************************************}
  686. procedure TestTHugeCollection;
  687. var
  688.   Collection : PHugeCollection;
  689.   Reader : PTestObjectReader;
  690.   Window : PResultsWindow;
  691. begin
  692.   Collection := New(PHugeCollection, Init(TotalItems, 50));
  693.   if Collection = nil
  694.     then Exit;
  695.   Reader := New(PTestObjectReader, Init(Collection));
  696.   Window := New(PResultsWindow, Init('THugeCollection test', Reader));
  697.   InitTest(Reader, Window, CreateTestObject);
  698.   TestSequence(Collection, Dynamic, UnSorted);
  699.   EndTest;
  700. end;
  701.  
  702. {****************************************************************************}
  703. { TestTHugeCollectionStack                                                   }
  704. {****************************************************************************}
  705. procedure TestTHugeCollectionStack;
  706. var
  707.   Stack : PHugeCollectionStack;
  708.   Reader : PTestObjectReader;
  709.   Window : PResultsWindow;
  710. begin
  711.   Stack := New(PHugeCollectionStack, Init(30, 50));
  712.   if Stack = nil
  713.     then Exit;
  714.   Reader := New(PTestObjectReader, Init(Stack));
  715.   Window := New(PResultsWindow, Init('THugeCollectionStack test', Reader));
  716.   InitTest(Reader, Window, CreateTestObject);
  717.   TestHugeCollectionStack(Stack);
  718.   EndTest;
  719. end;
  720.  
  721. {****************************************************************************}
  722. { TestTHugeSortedCollection                                                  }
  723. {****************************************************************************}
  724. procedure TestTHugeSortedCollection;
  725. var
  726.   Collection : PHugeSortedCollection;
  727.   Reader : PTestObjectReader;
  728.   Window : PResultsWindow;
  729. begin
  730.   Collection := New(PTestHugeSortedCollection, Init(TotalItems, 50));
  731.   if Collection = nil
  732.     then Exit;
  733.   Reader := New(PTestObjectReader, Init(Collection));
  734.   Window := New(PResultsWindow, Init('THugeSortedCollection test', Reader));
  735.   InitTest(Reader, Window, CreateTestObject);
  736.   TestSequence(Collection, Dynamic, Sorted);
  737.   EndTest;
  738. end;
  739.  
  740. {****************************************************************************}
  741. { TestTHugeStringCollection                                                  }
  742. {****************************************************************************}
  743. procedure TestTHugeStringCollection;
  744. var
  745.   Collection : PHugeStringCollection;
  746.   Reader : PStringReader;
  747.   Window : PResultsWindow;
  748. begin
  749.   Collection := New(PHugeStringCollection, Init(TotalItems, 50));
  750.   if Collection = nil
  751.     then Exit;
  752.   Reader := New(PStringReader, Init(Collection));
  753.   Window := New(PResultsWindow, Init('THugeStringCollection test', Reader));
  754.   InitTest(Reader, Window, CreateString);
  755.   TestSequence(Collection, Dynamic, Sorted);
  756.   EndTest;
  757. end;
  758.  
  759. {****************************************************************************}
  760. { TestTHugeUnSortedStrCollection                                             }
  761. {****************************************************************************}
  762. procedure TestTHugeUnSortedStrCollection;
  763. var
  764.   Collection : PHugeUnSortedStrCollection;
  765.   Reader : PStringReader;
  766.   Window : PResultsWindow;
  767. begin
  768.   Collection := New(PHugeUnSortedStrCollection, Init(TotalItems, 50));
  769.   if Collection = nil
  770.     then Exit;
  771.   Reader := New(PStringReader, Init(Collection));
  772.   Window := New(PResultsWindow, Init('THugeUnSortedStrCollection test',
  773.     Reader));
  774.   InitTest(Reader, Window, CreateString);
  775.   TestSequence(Collection, Dynamic, UnSorted);
  776.   EndTest;
  777. end;
  778.  
  779. {****************************************************************************}
  780. { TestTLinkedStack                                                           }
  781. {****************************************************************************}
  782. procedure TestTLinkedStack;
  783. var
  784.   Stack: PLinkedStack;
  785.   Reader : PTestListNodeReader;
  786.   Window : PResultsWindow;
  787. begin
  788.   Stack := New(PLinkedStack, Init);
  789.   if Stack = nil
  790.     then Exit;
  791.   Reader := New(PTestListNodeReader, Init(Stack));
  792.   Window := New(PResultsWindow, Init('TLinkedStack test', Reader));
  793.   InitTest(Reader, Window, CreateListNode);
  794.   TestLinkedStack(Stack);
  795.   EndTest;
  796. end;
  797.  
  798. {****************************************************************************}
  799. { TestTListDouble                                                            }
  800. {****************************************************************************}
  801. procedure TestTListDouble;
  802. var
  803.   List : PDoubleList;
  804.   Reader : PTestDoubleNodeReader;
  805.   Window : PResultsWindow;
  806. begin
  807.   List := New(PDoubleList, Init);
  808.   if List = nil
  809.     then Exit;
  810.   Reader := New(PTestDoubleNodeReader, Init(List));
  811.   Window := New(PResultsWindow, Init('TDoubleList test', Reader));
  812.   InitTest(Reader, Window, CreateDoubleNode);
  813.   TestSequence(List, Dynamic, UnSorted);
  814.   EndTest;
  815. end;
  816.  
  817. {****************************************************************************}
  818. { TestTListSingle                                                            }
  819. {****************************************************************************}
  820. procedure TestTListSingle;
  821. var
  822.   List : PList;
  823.   Reader : PTestListNodeReader;
  824.   Window : PResultsWindow;
  825. begin
  826.   List := New(PList, Init);
  827.   if List = nil
  828.     then Exit;
  829.   Reader := New(PTestListNodeReader, Init(List));
  830.   Window := New(PResultsWindow, Init('TList test', Reader));
  831.   InitTest(Reader, Window, CreateListNode);
  832.   TestSequence(List, Dynamic, UnSorted);
  833.   EndTest;
  834. end;
  835.  
  836. {****************************************************************************}
  837. { TestTObjectBPlusTree                                                       }
  838. {****************************************************************************}
  839. procedure TestTObjectBPlusTree;
  840. var
  841.   Stream : PStream;
  842.   Tree : PTestObjectBPlusTree;
  843.   Reader : PObjectBTreeReader;
  844.   Window : PResultsWindow;
  845.   OldTotalItems : LongInt;
  846. begin
  847.   Stream := New(PBufStream, Init(TreesTempFileName, stCreate, 2048));
  848.   if Stream = nil
  849.     then begin
  850.            Application^.OutOfMemory;
  851.            Exit;
  852.          end { if }
  853.   else if Stream^.Status <> stOk
  854.     then begin
  855.            MessageBox('Error ocurred while initializing stream.',
  856.              nil, mfError + mfOkButton);
  857.            Dispose(Stream, Done);
  858.            Exit;
  859.          end; { if }
  860.   Tree := New(PTestObjectBPlusTree, Init(13, 20, SizeOf(TTestStaticObject),
  861.     SizeOf(String5), Stream, 50, 50));
  862.   if Tree = nil
  863.     then Exit;
  864.   Reader := New(PObjectBTreeReader, Init(Tree));
  865.   Window := New(PResultsWindow, Init('TObjectBPlusTree test', Reader));
  866.  
  867.   OldTotalItems := TotalItems;
  868.   if TotalItems > 3000
  869.     then begin
  870.            Writeln(Window^.T, 'For speed, number of items has been reduced '+
  871.              'to 3000.');
  872.            Writeln(Window^.T);
  873.            TotalItems := 3000;
  874.          end; { if }
  875.   Writeln(Window^.T, 'The size of the buffer is 22 Kb.');
  876.   Writeln(Window^.T);
  877.  
  878.   InitTest(Reader, Window, CreateStaticObject);
  879.   TestGraph(Tree);
  880.   if PResultsWindow(Desktop^.Current) = Window
  881.     then begin
  882.            Dispose(Tree, Done);
  883.            Reader^.Container := nil;
  884.            NotifyDataChange;
  885.            Window^.Redraw;
  886.          end; { if }
  887.   Dispose(Stream, Done);
  888.   TotalItems := OldTotalItems;
  889.   EndTest;
  890. end;
  891.  
  892. {****************************************************************************}
  893. { TestTObjectBTree                                                           }
  894. {****************************************************************************}
  895. procedure TestTObjectBTree;
  896. var
  897.   Stream : PStream;
  898.   Tree : PTestObjectBTree;
  899.   Reader : PObjectBTreeReader;
  900.   Window : PResultsWindow;
  901.   OldTotalItems : LongInt;
  902. begin
  903.   Stream := New(PBufStream, Init(TreesTempFileName, stCreate, 2048));
  904.   if Stream = nil
  905.     then begin
  906.            Application^.OutOfMemory;
  907.            Exit;
  908.          end { if }
  909.   else if Stream^.Status <> stOk
  910.     then begin
  911.            MessageBox('Error ocurred while initializing stream.',
  912.              nil, mfError + mfOkButton);
  913.            Dispose(Stream, Done);
  914.            Exit;
  915.          end; { if }
  916.   Tree := New(PTestObjectBTree, Init(15, SizeOf(TTestStaticObject),
  917.     Stream, 100));
  918.   if Tree = nil
  919.     then Exit;
  920.   Reader := New(PObjectBTreeReader, Init(Tree));
  921.   Window := New(PResultsWindow, Init('TObjectBTree test', Reader));
  922.  
  923.   OldTotalItems := TotalItems;
  924.   if TotalItems > 3000
  925.     then begin
  926.            Writeln(Window^.T, 'For speed, number of items has been reduced '+
  927.              'to 3000.');
  928.            Writeln(Window^.T);
  929.            TotalItems := 3000;
  930.          end; { if }
  931.   Writeln(Window^.T, 'The size of the buffer is 20 Kb.');
  932.   Writeln(Window^.T);
  933.  
  934.   InitTest(Reader, Window, CreateStaticObject);
  935.   TestGraph(Tree);
  936.   if PResultsWindow(Desktop^.Current) = Window
  937.     then begin
  938.            Dispose(Tree, Done);
  939.            Reader^.Container := nil;
  940.            NotifyDataChange;
  941.            Window^.Redraw;
  942.          end; { if }
  943.   Dispose(Stream, Done);
  944.   TotalItems := OldTotalItems;
  945.   EndTest;
  946. end;
  947.  
  948. {****************************************************************************}
  949. { TestTObjectTable                                                           }
  950. {****************************************************************************}
  951. procedure TestTObjectTable;
  952. var
  953.   Stream : PStream;
  954.   Structure : PFieldStructure;
  955.   Table : PObjectTable;
  956.   Reader : PTestStaticObjectReader;
  957.   Window : PResultsWindow;
  958. begin
  959.   Stream := New(PBufStream, Init(TablesTempFileName, stCreate, 1024));
  960.   if Stream = nil
  961.      then begin
  962.             Application^.OutOfMemory;
  963.             Exit;
  964.           end; { if }
  965.   Structure := New(PFieldStructure, Init(2, 1));
  966.   if Structure = nil
  967.      then begin
  968.             Dispose(Stream, Done);
  969.             Application^.OutOfMemory;
  970.             Exit;
  971.           end; { if }
  972.   Structure^.Insert(NewStringField('String', 5));
  973.   Structure^.Insert(NewIntegerField('Index'));
  974.  
  975.   Table := New(PObjectTable, Init(Structure, Stream));
  976.   if Table = nil
  977.      then begin
  978.             Dispose(Structure,Done);
  979.             Dispose(Stream,Done);
  980.             Exit;
  981.           end;
  982.  
  983.   Reader := New(PTestStaticObjectReader, Init(Table));
  984.   Window := New(PResultsWindow, Init('TObjectTable test', Reader));
  985.   InitTest(Reader, Window, CreateStaticObject);
  986.   TestSequence(Table, Dynamic, UnSorted);
  987.   if PResultsWindow(Desktop^.Current) = Window
  988.     then begin
  989.            Dispose(Table, Done);
  990.            Reader^.Container := nil;
  991.            NotifyDataChange;
  992.            Window^.Redraw;
  993.          end; { if }
  994.   Dispose(Stream, Done);
  995.   EndTest;
  996. end;
  997.  
  998. {****************************************************************************}
  999. { TestTQueue                                                                 }
  1000. {****************************************************************************}
  1001. procedure TestTQueue;
  1002. var
  1003.   Queue : PQueue;
  1004.   Reader : PTestListNodeReader;
  1005.   Window : PResultsWindow;
  1006. begin
  1007.   Queue := New(PQueue, Init);
  1008.   if Queue = nil
  1009.     then Exit;
  1010.   Reader := New(PTestListNodeReader, Init(Queue));
  1011.   Window := New(PResultsWindow, Init('TQueue test', Reader));
  1012.   InitTest(Reader, Window, CreateListNode);
  1013.   TestQueue(Queue);
  1014.   EndTest;
  1015. end;
  1016.  
  1017. {****************************************************************************}
  1018. { TestTResizableHugeArray                                                    }
  1019. {****************************************************************************}
  1020. procedure TestTResizableHugeArray;
  1021. var
  1022.   DemoArray: PResizableHugeArray;
  1023.   Reader : PTestRecReader;
  1024.   Window : PResultsWindow;
  1025. begin
  1026.   DemoArray := New(PResizableHugeArray, Init(TotalItems, 100,
  1027.     SizeOf(TTestRec)));
  1028.   if DemoArray = nil
  1029.     then Exit;
  1030.   Reader := New(PTestRecReader, Init(DemoArray));
  1031.   Window := New(PResultsWindow, Init('TResizableHugeArray test', Reader));
  1032.   InitTest(Reader, Window, nil);
  1033.   UseNonDynamicTestRec := True;
  1034.   TestingMemArray := True;
  1035.   TestResizableArray(DemoArray);
  1036.   UseNonDynamicTestRec := False;
  1037.   TestingMemArray := False;
  1038.   EndTest;
  1039. end;
  1040.  
  1041. {****************************************************************************}
  1042. { TestTResizableHugeObjectArray                                              }
  1043. {****************************************************************************}
  1044. procedure TestTResizableHugeObjectArray;
  1045. var
  1046.   DemoArray: PResizableHugeObjectArray;
  1047.   Reader : PTestObjectReader;
  1048.   Window : PResultsWindow;
  1049. begin
  1050.   DemoArray := New(PResizableHugeObjectArray, Init(TotalItems, 100,
  1051.     SizeOf(TTestRec)));
  1052.   if DemoArray = nil
  1053.     then Exit;
  1054.   Reader := New(PTestObjectReader, Init(DemoArray));
  1055.   Window := New(PResultsWindow, Init('TResizableHugeObjectArray test',
  1056.     Reader));
  1057.   InitTest(Reader, Window, nil);
  1058.   UseNonDynamicTestObject := True;
  1059.   TestingMemArray := True;
  1060.   TestResizableArray(DemoArray);
  1061.   UseNonDynamicTestObject := False;
  1062.   TestingMemArray := False;
  1063.   EndTest;
  1064. end;
  1065.  
  1066. {****************************************************************************}
  1067. { TestTResizableStdArray                                                     }
  1068. {****************************************************************************}
  1069. procedure TestTResizableStdArray;
  1070. var
  1071.   DemoArray: PResizableStdArray;
  1072.   Reader : PTestRecReader;
  1073.   Window : PResultsWindow;
  1074. begin
  1075.   DemoArray := New(PResizableStdArray, Init(TotalItems, 100,
  1076.     SizeOf(TTestRec)));
  1077.   if DemoArray = nil
  1078.     then Exit;
  1079.   Reader := New(PTestRecReader, Init(DemoArray));
  1080.   Window := New(PResultsWindow, Init('TResizableStdArray test', Reader));
  1081.   InitTest(Reader, Window, nil);
  1082.   UseNonDynamicTestRec := True;
  1083.   TestingMemArray := True;
  1084.   TestResizableArray(DemoArray);
  1085.   UseNonDynamicTestRec := False;
  1086.   TestingMemArray := False;
  1087.   EndTest;
  1088. end;
  1089.  
  1090. {****************************************************************************}
  1091. { TestTResizableStdObjectArray                                               }
  1092. {****************************************************************************}
  1093. procedure TestTResizableStdObjectArray;
  1094. var
  1095.   DemoArray: PResizableStdObjectArray;
  1096.   Reader : PTestObjectReader;
  1097.   Window : PResultsWindow;
  1098. begin
  1099.   DemoArray := New(PResizableStdObjectArray, Init(TotalItems, 100,
  1100.     SizeOf(TTestRec)));
  1101.   if DemoArray = nil
  1102.     then Exit;
  1103.   Reader := New(PTestObjectReader, Init(DemoArray));
  1104.   Window := New(PResultsWindow, Init('TResizableStdObjectArray test',
  1105.     Reader));
  1106.   InitTest(Reader, Window, nil);
  1107.   UseNonDynamicTestObject := True;
  1108.   TestingMemArray := True;
  1109.   TestResizableArray(DemoArray);
  1110.   UseNonDynamicTestObject := False;
  1111.   TestingMemArray := False;
  1112.   EndTest;
  1113. end;
  1114.  
  1115. {****************************************************************************}
  1116. { TestTSortedListDouble                                                      }
  1117. {****************************************************************************}
  1118. procedure TestTSortedListDouble;
  1119. var
  1120.   List : PSortedDoubleList;
  1121.   Reader : PTestDoubleNodeReader;
  1122.   Window : PResultsWindow;
  1123.   OldTotalItems : LongInt;
  1124. begin
  1125.   List := New(PSortedDoubleList, Init);
  1126.   if List = nil
  1127.     then Exit;
  1128.   Reader := New(PTestDoubleNodeReader, Init(List));
  1129.   Window := New(PResultsWindow, Init('TSortedDoubleList test',
  1130.     Reader));
  1131.   OldTotalItems := TotalItems;
  1132.   if TotalItems > 2000
  1133.     then begin
  1134.            Writeln(Window^.T, 'For speed, number of items has been reduced '+
  1135.              'to 2000.');
  1136.            Writeln(Window^.T);
  1137.            TotalItems := 2000;
  1138.          end; { if }
  1139.   InitTest(Reader, Window, CreateDoubleNode);
  1140.   TestSequence(List, Dynamic, Sorted);
  1141.   EndTest;
  1142.   TotalItems := OldTotalItems;
  1143. end;
  1144.  
  1145. {****************************************************************************}
  1146. { TestTSortedListSingle                                                      }
  1147. {****************************************************************************}
  1148. procedure TestTSortedListSingle;
  1149. var
  1150.   List : PSortedList;
  1151.   Reader : PTestListNodeReader;
  1152.   Window : PResultsWindow;
  1153.   OldTotalItems : LongInt;
  1154. begin
  1155.   List := New(PSortedList, Init);
  1156.   if List = nil
  1157.     then Exit;
  1158.   Reader := New(PTestListNodeReader, Init(List));
  1159.   Window := New(PResultsWindow, Init('TSortedList test',
  1160.     Reader));
  1161.   OldTotalItems := TotalItems;
  1162.   if TotalItems > 2000
  1163.     then begin
  1164.            Writeln(Window^.T, 'For speed, number of items has been reduced '+
  1165.              'to 2000.');
  1166.            Writeln(Window^.T);
  1167.            TotalItems := 2000;
  1168.          end; { if }
  1169.   InitTest(Reader, Window, CreateListNode);
  1170.   TestSequence(List, Dynamic, Sorted);
  1171.   EndTest;
  1172.   TotalItems := OldTotalItems;
  1173. end;
  1174.  
  1175. {****************************************************************************}
  1176. { TestTSortedHugeArray                                                       }
  1177. {****************************************************************************}
  1178. procedure TestTSortedHugeArray;
  1179. var
  1180.   DemoArray: PTestSortedHugeArray;
  1181.   Reader : PTestRecReader;
  1182.   Window : PResultsWindow;
  1183. begin
  1184.   DemoArray := New(PTestSortedHugeArray, Init(TotalItems, 100,
  1185.     SizeOf(TTestRec)));
  1186.   if DemoArray = nil
  1187.     then Exit;
  1188.   Reader := New(PTestRecReader, Init(DemoArray));
  1189.   Window := New(PResultsWindow, Init('TSortedHugeArray test', Reader));
  1190.   InitTest(Reader, Window, nil);
  1191.   UseNonDynamicTestRec := True;
  1192.   TestingMemArray := True;
  1193.   TestSortedArray(DemoArray);
  1194.   UseNonDynamicTestRec := False;
  1195.   TestingMemArray := False;
  1196.   EndTest;
  1197. end;
  1198.  
  1199. {****************************************************************************}
  1200. { TestTSortedHugeObjectArray                                                 }
  1201. {****************************************************************************}
  1202. procedure TestTSortedHugeObjectArray;
  1203. var
  1204.   DemoArray: PTestSortedHugeObjectArray;
  1205.   Reader : PTestStaticObjectReader;
  1206.   Window : PResultsWindow;
  1207. begin
  1208.   DemoArray := New(PTestSortedHugeObjectArray, Init(TotalItems, 100,
  1209.     SizeOf(TTestStaticObject)));
  1210.   if DemoArray = nil
  1211.     then Exit;
  1212.   Reader := New(PTestStaticObjectReader, Init(DemoArray));
  1213.   Window := New(PResultsWindow, Init('TSortedHugeObjectArray test', Reader));
  1214.   InitTest(Reader, Window, nil);
  1215.   UseNonDynamicTestStaticObject := True;
  1216.   TestingMemArray := True;
  1217.   TestSortedArray(DemoArray);
  1218.   UseNonDynamicTestStaticObject := False;
  1219.   TestingMemArray := False;
  1220.   EndTest;
  1221. end;
  1222.  
  1223. {****************************************************************************}
  1224. { TestTSortedStdArray                                                        }
  1225. {****************************************************************************}
  1226. procedure TestTSortedStdArray;
  1227. var
  1228.   DemoArray: PTestSortedStdArray;
  1229.   Reader : PTestRecReader;
  1230.   Window : PResultsWindow;
  1231. begin
  1232.   DemoArray := New(PTestSortedStdArray, Init(TotalItems, 100,
  1233.     SizeOf(TTestRec)));
  1234.   if DemoArray = nil
  1235.     then Exit;
  1236.   Reader := New(PTestRecReader, Init(DemoArray));
  1237.   Window := New(PResultsWindow, Init('TSortedStdArray test', Reader));
  1238.   InitTest(Reader, Window, nil);
  1239.   UseNonDynamicTestRec := True;
  1240.   TestingMemArray := True;
  1241.   TestSortedArray(DemoArray);
  1242.   UseNonDynamicTestRec := False;
  1243.   TestingMemArray := False;
  1244.   EndTest;
  1245. end;
  1246.  
  1247. {****************************************************************************}
  1248. { TestTSortedStdObjectArray                                                  }
  1249. {****************************************************************************}
  1250. procedure TestTSortedStdObjectArray;
  1251. var
  1252.   DemoArray: PTestSortedStdObjectArray;
  1253.   Reader : PTestStaticObjectReader;
  1254.   Window : PResultsWindow;
  1255. begin
  1256.   DemoArray := New(PTestSortedStdObjectArray, Init(TotalItems, 100,
  1257.     SizeOf(TTestObject)));
  1258.   if DemoArray = nil
  1259.     then Exit;
  1260.   Reader := New(PTestStaticObjectReader, Init(DemoArray));
  1261.   Window := New(PResultsWindow, Init('TSortedStdObjectArray test', Reader));
  1262.   InitTest(Reader, Window, nil);
  1263.   UseNonDynamicTestStaticObject := True;
  1264.   TestingMemArray := True;
  1265.   TestSortedArray(DemoArray);
  1266.   UseNonDynamicTestStaticObject := False;
  1267.   TestingMemArray := False;
  1268.   EndTest;
  1269. end;
  1270.  
  1271. {****************************************************************************}
  1272. { TestTStdArray                                                              }
  1273. {****************************************************************************}
  1274. procedure TestTStdArray;
  1275. var
  1276.   DemoArray: PStdArray;
  1277.   Reader : PTestRecReader;
  1278.   Window : PResultsWindow;
  1279. begin
  1280.   DemoArray := New(PStdArray, Init(0, Pred(TotalItems),
  1281.     SizeOf(TTestRec)));
  1282.   if DemoArray = nil
  1283.     then Exit;
  1284.   Reader := New(PTestRecReader, Init(DemoArray));
  1285.   Window := New(PResultsWindow, Init('TStdArray test', Reader));
  1286.   InitTest(Reader, Window, nil);
  1287.   UseNonDynamicTestRec := True;
  1288.   TestingMemArray := True;
  1289.   TestArray(DemoArray);
  1290.   UseNonDynamicTestRec := False;
  1291.   TestingMemArray := False;
  1292.   EndTest;
  1293. end;
  1294.  
  1295. {****************************************************************************}
  1296. { TestTStdObjectArray                                                        }
  1297. {****************************************************************************}
  1298. procedure TestTStdObjectArray;
  1299. var
  1300.   DemoArray: PStdObjectArray;
  1301.   Reader : PTestObjectReader;
  1302.   Window : PResultsWindow;
  1303. begin
  1304.   DemoArray := New(PStdObjectArray, Init(0, Pred(TotalItems),
  1305.     SizeOf(TTestObject)));
  1306.   if DemoArray = nil
  1307.     then Exit;
  1308.   Reader := New(PTestObjectReader, Init(DemoArray));
  1309.   Window := New(PResultsWindow, Init('TStdObjectArray test', Reader));
  1310.   InitTest(Reader, Window, nil);
  1311.   UseNonDynamicTestObject := True;
  1312.   TestingMemArray := True;
  1313.   TestArray(DemoArray);
  1314.   UseNonDynamicTestObject := False;
  1315.   TestingMemArray := False;
  1316.   EndTest;
  1317. end;
  1318.  
  1319. {****************************************************************************}
  1320. { TestTStreamCollection                                                      }
  1321. {****************************************************************************}
  1322. procedure TestTStreamCollection;
  1323. var
  1324.   Collection : PStreamCollection;
  1325.   Reader : PTestObjectReader;
  1326.   Window : PResultsWindow;
  1327. begin
  1328.   Collection := New(PStreamCollection, Init(TotalItems, 50));
  1329.   if Collection = nil
  1330.     then Exit;
  1331.   Reader := New(PTestObjectReader, Init(Collection));
  1332.   Window := New(PResultsWindow, Init('TStreamCollection test', Reader));
  1333.   InitTest(Reader, Window, CreateTestObject);
  1334.   TestSequence(Collection, Dynamic, UnSorted);
  1335.   EndTest;
  1336. end;
  1337.  
  1338. {****************************************************************************}
  1339. { TestTStreamObjectArray                                                     }
  1340. {****************************************************************************}
  1341. procedure TestTStreamObjectArray;
  1342. var
  1343.   DemoArray: PStreamObjectArray;
  1344.   Reader : PTestStaticObjectReader;
  1345.   Window : PResultsWindow;
  1346. begin
  1347.   DemoArray := New(PStreamObjectArray, Init(0, Pred(TotalItems),
  1348.     SizeOf(TTestStaticObject)));
  1349.   if DemoArray = nil
  1350.     then Exit;
  1351.   Reader := New(PTestStaticObjectReader, Init(DemoArray));
  1352.   Window := New(PResultsWindow, Init('TStreamObjectArray test', Reader));
  1353.   InitTest(Reader, Window, CreateStaticObject);
  1354.   TestArray(DemoArray);
  1355.   EndTest;
  1356. end;
  1357.  
  1358. {****************************************************************************}
  1359. { TestTStreamSortedCollection                                                }
  1360. {****************************************************************************}
  1361. procedure TestTStreamSortedCollection;
  1362. var
  1363.   Collection : PStreamSortedCollection;
  1364.   Reader : PTestObjectReader;
  1365.   Window : PResultsWindow;
  1366. begin
  1367.   Collection := New(PTestStreamSortedCollection, Init(TotalItems, 50));
  1368.   if Collection = nil
  1369.     then Exit;
  1370.   Reader := New(PTestObjectReader, Init(Collection));
  1371.   Window := New(PResultsWindow, Init('TStreamSortedCollection test', Reader));
  1372.   InitTest(Reader, Window, CreateTestObject);
  1373.   TestSequence(Collection, Dynamic, Sorted);
  1374.   EndTest;
  1375. end;
  1376.  
  1377. {****************************************************************************}
  1378. { TestTStreamStack                                                           }
  1379. {****************************************************************************}
  1380. procedure TestTStreamStack;
  1381. var
  1382.   Stack: PStreamStack;
  1383.   Reader : PTestObjectReader;
  1384.   Window : PResultsWindow;
  1385. begin
  1386.   Stack := New(PStreamStack, Init(100, 10));
  1387.   if Stack = nil
  1388.     then Exit;
  1389.   Reader := New(PTestObjectReader, Init(Stack));
  1390.   Window := New(PResultsWindow, Init('TStreamStack test', Reader));
  1391.   InitTest(Reader, Window, CreateTestObject);
  1392.   TestStreamStack(Stack);
  1393.   EndTest;
  1394. end;
  1395.  
  1396. {****************************************************************************}
  1397. { TestTStreamStdArray                                                        }
  1398. {****************************************************************************}
  1399. procedure TestTStreamStdArray;
  1400. var
  1401.   DemoArray: PStreamStdArray;
  1402.   Reader : PTestRecReader;
  1403.   Window : PResultsWindow;
  1404. begin
  1405.   DemoArray := New(PStreamStdArray, Init(0, Pred(TotalItems), SizeOf(TTestRec)));
  1406.   if DemoArray = nil
  1407.     then Exit;
  1408.   Reader := New(PTestRecReader, Init(DemoArray));
  1409.   Window := New(PResultsWindow, Init('TStreamStdArray test', Reader));
  1410.   InitTest(Reader, Window, CreateTestRec);
  1411.   TestArray(DemoArray);
  1412.   EndTest;
  1413. end;
  1414.  
  1415. {****************************************************************************}
  1416. { TestTStreamStdObjectArray                                                  }
  1417. {****************************************************************************}
  1418. procedure TestTStreamStdObjectArray;
  1419. var
  1420.   DemoArray: PStreamStdObjectArray;
  1421.   Reader : PTestObjectReader;
  1422.   Window : PResultsWindow;
  1423. begin
  1424.   DemoArray := New(PStreamStdObjectArray, Init(0, Pred(TotalItems),
  1425.     SizeOf(TTestObject)));
  1426.   if DemoArray = nil
  1427.     then Exit;
  1428.   Reader := New(PTestObjectReader, Init(DemoArray));
  1429.   Window := New(PResultsWindow, Init('TStreamStdObjectArray test', Reader));
  1430.   InitTest(Reader, Window, CreateTestObject);
  1431.   TestArray(DemoArray);
  1432.   EndTest;
  1433. end;
  1434.  
  1435. {****************************************************************************}
  1436. { TestTStreamStringCollection                                                }
  1437. {****************************************************************************}
  1438. procedure TestTStreamStringCollection;
  1439. var
  1440.   Collection : PStreamStringCollection;
  1441.   Reader : PStringReader;
  1442.   Window : PResultsWindow;
  1443. begin
  1444.   Collection := New(PStreamStringCollection, Init(TotalItems, 50));
  1445.   if Collection = nil
  1446.     then Exit;
  1447.   Reader := New(PStringReader, Init(Collection));
  1448.   Window := New(PResultsWindow, Init('TStreamStringCollection test', Reader));
  1449.   InitTest(Reader, Window, CreateString);
  1450.   TestSequence(Collection, Dynamic, Sorted);
  1451.   EndTest;
  1452. end;
  1453.  
  1454. {****************************************************************************}
  1455. { TestTStreamUnSortedStrCollection                                           }
  1456. {****************************************************************************}
  1457. procedure TestTStreamUnSortedStrCollection;
  1458. var
  1459.   Collection : PStreamUnSortedStrCollection;
  1460.   Reader : PStringReader;
  1461.   Window : PResultsWindow;
  1462. begin
  1463.   Collection := New(PStreamUnSortedStrCollection, Init(TotalItems, 50));
  1464.   if Collection = nil
  1465.     then Exit;
  1466.   Reader := New(PStringReader, Init(Collection));
  1467.   Window := New(PResultsWindow, Init('TStreamUnSortedStrCollection test',
  1468.     Reader));
  1469.   InitTest(Reader, Window, CreateString);
  1470.   TestSequence(Collection, Dynamic, UnSorted);
  1471.   EndTest;
  1472. end;
  1473.  
  1474. {****************************************************************************}
  1475. { TestTTable                                                                 }
  1476. {****************************************************************************}
  1477. procedure TestTTable;
  1478. var
  1479.   Stream : PStream;
  1480.   Structure : PFieldStructure;
  1481.   Table : PTable;
  1482.   Reader : PTestRecReader;
  1483.   Window : PResultsWindow;
  1484. begin
  1485.   Stream := New(PBufStream, Init(TablesTempFileName, stCreate, 1024));
  1486.   if Stream = nil
  1487.      then begin
  1488.             Application^.OutOfMemory;
  1489.             Exit;
  1490.           end; { if }
  1491.   Structure := New(PFieldStructure, Init(2, 1));
  1492.   if Structure = nil
  1493.      then begin
  1494.             Dispose(Stream, Done);
  1495.             Application^.OutOfMemory;
  1496.             Exit;
  1497.           end; { if }
  1498.   Structure^.Insert(NewStringField('String', 5));
  1499.   Structure^.Insert(NewIntegerField('Index'));
  1500.  
  1501.   Table := New(PTable, Init(Structure, Stream));
  1502.   if Table = nil
  1503.     then Exit;
  1504.   Reader := New(PTestRecReader, Init(Table));
  1505.   Window := New(PResultsWindow, Init('TTable test', Reader));
  1506.   InitTest(Reader, Window, CreateTestRec);
  1507.   TestSequence(Table, Dynamic, UnSorted);
  1508.   if PResultsWindow(Desktop^.Current) = Window
  1509.     then begin
  1510.            Dispose(Table, Done);
  1511.            Reader^.Container := nil;
  1512.            NotifyDataChange;
  1513.            Window^.Redraw;
  1514.          end; { if }
  1515.   Dispose(Stream, Done);
  1516.   EndTest;
  1517. end;
  1518.  
  1519. end.